// #pragma once
#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include <iostream>
#include <string>
#include<functional>
#include<pthread.h>
#include <sys/types.h>
#include <unistd.h>

//version 2 模板传参
// namespace ThreadModule 
// {
    
//     static int number = 1;
//     //设置线程状态
//     enum class TSTATUS
//     {
//         NEW,
//         Running,
//         Stop
//     };

//     template<class T>
//     //线程封装
//     class Thread 
//     {
//         //////////////放在同一模板下////////////////////
//         using func_t = std::function<void(T)>;
//         //执行函数（不可见）
//         private:
//             //成员方法
//             static void*Routine(void*args)
//             {
//                 Thread*t = static_cast<Thread*>(args);
//                 t->_status = TSTATUS::Running;
//                 t->_func(t->_data);
//                 return nullptr;
//             }

//             //分离标志
//             void EnableDetach()
//             {
//                 _joinable = false;
//             }
//         public:

//             Thread(func_t func,T data)
//             :_func(func),
//             _status(TSTATUS::NEW),
//             _joinable(true),
//             _data(data)
//             {
//                 _name = "Thread-" + std::to_string(number++);
//                 _pid = getpid();
//             }
//             ~Thread() {}
//             bool Start()
//             {
//                 if(_status != TSTATUS::Running)
//                 {
//                     //创建线程
//                     int n = ::pthread_create(&_tid,nullptr,Routine,this);
//                     if(n!=0)
//                     return false;
//                     _status = TSTATUS::Running;
//                     return true;
//                 }
//                 return false;
//             }
//             bool Stop()
//             {
//                 if(_status == TSTATUS::Running)
//                 {
//                     //以信号的方式向线程发终止消息
//                     int n = ::pthread_cancel(_tid);
//                     if(n != 0)
//                     return false;
//                     _status = TSTATUS::Stop;
//                     return true;
//                 }
//                 return false;

//             }
//             bool Join()
//             {
//                 if(_joinable)
//                 {
//                     //等待线程
//                     int n = ::pthread_join(_tid, nullptr);
//                     if(n!=0) return false;
//                     _status = TSTATUS::Stop;
//                     return true;
//                 }
//                 return false;

//             }

//             void Detach()
//             {
//                 //分离线程，使进程不再等待回收
//                 EnableDetach();
//                 ::pthread_detach(_tid);
//             }
//             //判断线程是否分离
//             bool IsJoinDetach()
//             {
//                 return _joinable;
//             }

//             std::string GetName()
//             {
//                 return _name;
//             }
//         private:

//             std::string _name;
//             pthread_t _tid;
//             pid_t _pid;
//             bool _joinable;//是否分离，默认不是
//             func_t _func;
//             TSTATUS _status;
//             T _data;
//     };

// } 


//version 1不传参
namespace ThreadModule 
{
    using func_t = std::function<void(std::string name)>;
    static int number = 1;
    //设置线程状态
    enum class TSTATUS
    {
        NEW,
        Running,
        Stop
    };
    //线程封装
    class Thread 
    {
    //执行函数（不可见）
    private:
        //成员方法
        static void*Routine(void*args)
        {
            Thread*t = static_cast<Thread*>(args);
            t->_status = TSTATUS::Running;
            t->_func(t->GetName());
            return nullptr;
        }

        //分离标志
        void EnableDetach()
        {
            _joinable = false;
        }
    public:

        Thread(func_t func)
        :_func(func),
        _status(TSTATUS::NEW),
        _joinable(true)
        {
            _name = "Thread-" + std::to_string(number++);
            _pid = getpid();
        }
        ~Thread() {}
        bool Start()
        {
            if(_status != TSTATUS::Running)
            {
                //创建线程
                int n = ::pthread_create(&_tid,nullptr,Routine,this);
                if(n!=0)
                return false;
                _status = TSTATUS::Running;
                return true;
            }
            return false;
        }
        bool Stop()
        {
            if(_status == TSTATUS::Running)
            {
                //以信号的方式向线程发终止消息
                int n = ::pthread_cancel(_tid);
                if(n != 0)
                return false;
                _status = TSTATUS::Stop;
                return true;
            }
            return false;

        }
        bool Join()
        {
            if(_joinable)
            {
                //等待线程
                int n = ::pthread_join(_tid, nullptr);
                if(n!=0) return false;
                _status = TSTATUS::Stop;
                return true;
            }
            return false;

        }

        void Detach()
        {
            //分离线程，使进程不再等待回收
            EnableDetach();
            ::pthread_detach(_tid);
        }
        //判断线程是否分离
        bool IsJoinDetach()
        {
            return _joinable;
        }

        std::string GetName()
        {
            return _name;
        }
    private:

        std::string _name;
        pthread_t _tid;
        pid_t _pid;
        bool _joinable;//是否分离，默认不是
        func_t _func;
        TSTATUS _status;
    };

} // namespace ThreadModule

#endif